home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 9 / CDACTUAL9.iso / share / Dos / VARIOS / pascal / MEMORY.SWG / 0002_Re: 32bit Move() and Fillchar() replacem.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1996-02-21  |  3.0 KB  |  116 lines
  1. {
  2. > >If anyone wants to see my "improved" move() and fillchar() which I put
  3. > >into a unit which I almost always link in I'd be happy to post it.  (I
  4. > >know that TCA has an even better one though, in case he'd like to post
  5. > >his version as well)
  6. >
  7. > Oh, fine.  Now that the world knows, I suppose I have to post it ;)
  8. >
  9. Thank you for so graciously accepting the terms before anyone wanted me
  10. to post my much more elementary 16-bit version as below:
  11. }
  12. procedure move (var src, dest; count : word); assembler;
  13.  
  14. asm
  15.   push ds
  16.     mov bx, count
  17.     mov cx, bx
  18.     shr cx, 1
  19.  
  20.     les di, src
  21.     lds si, dest
  22.     rep movsw
  23.  
  24.     and bx, 1
  25.     jz @NoMovsB
  26.     movsb
  27.    @NoMovsB: 
  28.  
  29.   pop ds
  30. end;
  31.  
  32. > This is a 32bit move() replacement.  Just throw the procedure in at the 
  33. > top of your program, and all your move() calls will work a little faster
  34. > (about 4 times faster for counts above 128 bytes).
  35. > 
  36. > procedure move(var Source,Dest; Count:word); assembler;
  37. > asm
  38. >     push    ds
  39. >     les    di,Dest
  40. >     lds    si,Source
  41. >     mov    cx,count
  42. >     mov    bx,cx
  43. >     shr    cx,2
  44. >     db 66h;    rep movsw
  45. >     and    bx,3
  46. >     mov    cx,bx
  47. >     rep    movsb
  48. >     pop    ds
  49. > end;
  50. >
  51. I remember yours looking a little different then that, maybe I'm thinking 
  52. of fillchar (later on)... but not to be picky, since dx isn't used, 
  53. couldn't you use mov dx, ds and mov ds, dx instead of push and pop 
  54. respectively?
  55.  
  56. > The fillchar() replacement isn't as nice, since with fillchar you can do 
  57. > things like: fillchar(foo,128,'H'); or fillchar(foo,128,TRUE);  
  58. > That makes conversions more difficult.  Still, for those of you who don't 
  59. > do that:
  60. > 
  61. > procedure fillchar(var X; Count:word; Value:byte); assembler;
  62. > asm
  63. >     les    di,X
  64. >     mov    cx,count
  65. >     mov    al,value
  66. >     mov    ah,al
  67. >     mov    bx,ax
  68. >     db 66h;    shl ax,16
  69. >     mov    ax,bx
  70. >     mov    bx,cx
  71. >     shr    cx,2
  72. >     db 66h; rep stosw
  73. >     and    bx,3
  74. >     mov    cx,bx
  75. >     rep    stosb
  76. > end;
  77. > 
  78. Hmmm... you must have rewritten both of them since I last saw them, as I 
  79. remember something utilizing adc in one of those... oh well, thse look 
  80. more logical anyway :)
  81.  
  82. > To get around the character or boolean types, do ord('H') or ord(TRUE).
  83. > (It all compiles to the same code).
  84. > 
  85. > This procedure will only increase the speed of fillchar() calls when the 
  86. > Count is above 128 or so.  It will also fillchar to pointers faster than 
  87. > arrays (since pointers are aligned, and arrays are [usually] not).  I 
  88. > just wrote the fillchar() procedure, so it is not as optimized as it
  89. > could be.
  90. > 
  91. How about I put up my fillchar as well, just for comparison's sake (it's, 
  92. once again, only 16-bit, but it seems to work just fine anyway :)
  93.  
  94. procedure FillChar (var src, dest; count : word; value : byte); assembler;
  95.  
  96. asm
  97.   mov bx, count
  98.   mov cx, bx
  99.   shr cx, 1
  100.  
  101.   mov al, value
  102.   mov ah, al
  103.  
  104.   les di, dest
  105.   rep stosw
  106.  
  107.   and bx, 1
  108.   jz @NoStosB
  109.   stosb
  110.  @NoStosB:
  111. end;
  112.  
  113. In other words it's my move() only with ax = 257*value and, well, a fill
  114. instead of a move. :)
  115.  
  116.